package a.j;

import a.d.s;
import a.d.t;
import a.d.w;

import java.awt.*;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.Rectangle2D.Double;

public class ne
  implements jd.g_, jd.f_, jd.d_, jd.c_, jd.i_
{
  private static final double a = 10.0D;
  private static final double b = 0.5D;
  private s c = new s(10.0D, 10.0D);
  private w d = new w(0.5D, 0.5D);
  public static boolean e;
  
  public s a()
  {
    return this.c;
  }
  
  private static boolean a(s params)
  {
    boolean bool = ld.E;
    if (!bool) {
      if (params == null) {
        return false;
      }
    }
    double d1 = params.b();
    if (!bool) {
      if (d1 >= 0.0D)
      {
        if (bool) {
          break label57;
        }
        if (!Double.isNaN(d1))
        {
          if (bool) {
            break label62;
          }
          if (!Double.isInfinite(d1)) {
            break label58;
          }
        }
      }
    }
    label57:
    return false;
    label58:
    label62:
    double d2 = params.c();
    if (!bool) {
      if (d2 >= 0.0D)
      {
        if (bool) {
          break label99;
        }
        if (!Double.isNaN(d2))
        {
          if (bool) {
            break label101;
          }
          if (!Double.isInfinite(d2)) {
            break label100;
          }
        }
      }
    }
    label99:
    return false;
    label100:
    label101:
    return true;
  }
  
  public void b(s params)
  {
    if (!ld.E)
    {
      if (a(params)) {
        this.c = params;
      }
    }
    else if (!ld.D) {
      return;
    }
    throw new IllegalArgumentException();
  }
  
  public void a(double paramDouble1, double paramDouble2)
  {
    b(new s(paramDouble1, paramDouble2));
  }
  
  public w b()
  {
    return this.d;
  }
  
  private static boolean a(w paramw)
  {
    boolean bool = ld.E;
    if (!bool) {
      if (paramw == null) {
        return false;
      }
    }
    double d1 = paramw.a();
    if (!bool) {
      if (d1 >= 0.0D)
      {
        if (bool) {
          break label56;
        }
        if (1.0D >= d1)
        {
          if (bool) {
            break label61;
          }
          if (!Double.isNaN(d1)) {
            break label57;
          }
        }
      }
    }
    label56:
    return false;
    label57:
    label61:
    double d2 = paramw.b();
    if (!bool) {
      if (d2 >= 0.0D)
      {
        if (bool) {
          break label97;
        }
        if (1.0D >= d2)
        {
          if (bool) {
            break label99;
          }
          if (!Double.isNaN(d2)) {
            break label98;
          }
        }
      }
    }
    label97:
    return false;
    label98:
    label99:
    return true;
  }
  
  public void b(w paramw)
  {
    if (!ld.E)
    {
      if (a(paramw)) {
        this.d = paramw;
      }
    }
    else if (!ld.D) {
      return;
    }
    throw new IllegalArgumentException();
  }
  
  public void b(double paramDouble1, double paramDouble2)
  {
    b(new w(paramDouble1, paramDouble2));
  }
  
  public boolean a(jd paramjd, double paramDouble1, double paramDouble2)
  {
    return paramjd.o().a(paramDouble1, paramDouble2);
  }
  
  public boolean a(jd paramjd, double paramDouble1, double paramDouble2, double paramDouble3, double paramDouble4, Point2D paramPoint2D)
  {
    boolean bool2 = ld.E;
    boolean bool1 = ld.D;
    if (!bool2) {
      if (paramjd.a(paramDouble1, paramDouble2))
      {
        if (!bool2)
        {
          if (!paramjd.a(paramDouble3, paramDouble4)) {
            break label78;
          }
          paramPoint2D.setLocation(paramDouble3, paramDouble4);
        }
        return false;
      }
    }
    if (!bool2)
    {
      if (!paramjd.a(paramDouble3, paramDouble4)) {
        paramPoint2D.setLocation(paramDouble1, paramDouble2);
      }
    }
    else {
      return false;
    }
    label78:
    double d1 = Math.sqrt((paramDouble3 - paramDouble1) * (paramDouble3 - paramDouble1) + (paramDouble4 - paramDouble2) * (paramDouble4 - paramDouble2));
    if (!bool2)
    {
      if (!Double.isNaN(d1))
      {
        if (bool2) {
          break label148;
        }
        if (!Double.isInfinite(d1)) {}
      }
      else
      {
        paramPoint2D.setLocation(paramDouble1, paramDouble2);
      }
    }
    else {
      return true;
    }
    label148:
    double d2 = (paramDouble3 - paramDouble1) / 2.0D;
    double d3 = (paramDouble4 - paramDouble2) / 2.0D;
    double d4 = paramDouble1 + d2;
    double d5 = paramDouble2 + d3;
    if (d1 > 0.1D)
    {
      d1 /= 2.0D;
      d2 /= 2.0D;
      d3 /= 2.0D;
    }
    label263:
    do
    {
      if (bool1) {
        break label281;
      }
      if (paramjd.a(d4, d5))
      {
        d4 += d2;
        d5 += d3;
        if (bool2) {
          break label263;
        }
        if (!bool1) {
          break;
        }
      }
      d4 -= d2;
      d5 -= d3;
      if (!bool1) {
        break;
      }
      paramPoint2D.setLocation(d4, d5);
    } while (bool2);
    label281:
    return true;
  }
  
  public void a(jd paramjd, Graphics2D paramGraphics2D)
  {
    boolean bool = ld.E;
    Stroke localStroke = paramGraphics2D.getStroke();
    Paint localPaint = paramGraphics2D.getPaint();
    Color localColor = paramGraphics2D.getColor();
    ld localld = paramjd.b();
    Rectangle2D localRectangle2D = jd.d(paramjd);
    if (!bool)
    {
      if (b(localld, paramjd, paramGraphics2D)) {
        paramGraphics2D.fill(localRectangle2D);
      }
      if (bool) {}
    }
    else if (c(localld, paramjd, paramGraphics2D))
    {
      paramGraphics2D.draw(localRectangle2D);
    }
    a(localld, paramjd, paramGraphics2D);
    paramGraphics2D.setColor(localColor);
    paramGraphics2D.setPaint(localPaint);
    paramGraphics2D.setStroke(localStroke);
  }
  
  protected void a(ld paramld, jd paramjd, Graphics2D paramGraphics2D)
  {
    boolean bool = ld.E;
    if ((bool) || (jd.a(paramjd, paramGraphics2D)))
    {
      t localt = paramjd.o();
      Rectangle2D.Double localDouble = hb.a().k;
      localDouble.setFrame(localt.d() - 2.0D, localt.e() - 2.0D, localt.b() + 4.0D, localt.c() + 4.0D);
      Color localColor = c(paramld, paramjd, true);
      if (!bool) {}
      paramGraphics2D.setColor(localColor == null ? Color.BLACK : localColor);
      paramGraphics2D.setStroke(c.e);
      paramGraphics2D.draw(localDouble);
    }
  }
  
  protected boolean b(ld paramld, jd paramjd, Graphics2D paramGraphics2D)
  {
    Paint localPaint = a(paramld, paramjd, jd.a(paramjd, paramGraphics2D));
    if (!ld.E)
    {
      if (localPaint != null) {
        paramGraphics2D.setPaint(localPaint);
      }
    }
    else {
      return true;
    }
    return false;
  }
  
  protected Paint a(ld paramld, jd paramjd, boolean paramBoolean)
  {
    return a(paramld, paramBoolean);
  }
  
  protected Paint a(ld paramld, boolean paramBoolean)
  {
    Color localColor = paramld.o();
    if (paramld.H())
    {
      if (ld.E) {
        break label28;
      }
      if (localColor != null) {
        return localColor.darker();
      }
    }
    label28:
    return localColor;
  }
  
  protected boolean c(ld paramld, jd paramjd, Graphics2D paramGraphics2D)
  {
    boolean bool = jd.a(paramjd, paramGraphics2D);
    Color localColor = c(paramld, paramjd, bool);
    if (localColor != null)
    {
      Stroke localStroke = b(paramld, paramjd, bool);
      if (!ld.E)
      {
        if (localStroke != null)
        {
          paramGraphics2D.setColor(localColor);
          paramGraphics2D.setStroke(localStroke);
        }
      }
      else {
        return true;
      }
    }
    return false;
  }
  
  protected Stroke b(ld paramld, jd paramjd, boolean paramBoolean)
  {
    return b(paramld, paramBoolean);
  }
  
  protected Stroke b(ld paramld, boolean paramBoolean)
  {
    return paramld.r();
  }
  
  protected Color c(ld paramld, jd paramjd, boolean paramBoolean)
  {
    return c(paramld, paramBoolean);
  }
  
  protected Color c(ld paramld, boolean paramBoolean)
  {
    Color localColor = paramld.q();
    if (!ld.E) {}
    return localColor == null ? Color.BLACK : localColor;
  }
  
  public t a(jd paramjd)
  {
    w localw1 = paramjd.h();
    s locals = a();
    double d1 = locals.b();
    double d2 = locals.c();
    w localw2 = b();
    return new t(localw1.a() - d1 * localw2.a(), localw1.b() - d2 * localw2.b(), d1, d2);
  }
  
  public void a(jd paramjd, Rectangle2D paramRectangle2D)
  {
    boolean bool = ld.E;
    t localt = paramjd.o();
    if (!bool) {
      if (paramRectangle2D.getWidth() <= 0.0D)
      {
        paramRectangle2D.setFrame(localt.d(), localt.e(), localt.b(), localt.c());
        if (!bool) {
          if (!ld.D) {
            return;
          }
        }
      }
      else
      {
        paramRectangle2D.add(localt.d(), localt.e());
      }
    }
    paramRectangle2D.add(localt.d() + localt.b(), localt.e() + localt.c());
  }
}



/* Location:           E:\idea\

 * Qualified Name:     a.j.ne

 * JD-Core Version:    0.7.0.1

 */